From 8a2f9e2e48b10c3f829ca2e13d7b62379b2f563a Mon Sep 17 00:00:00 2001 From: =?utf8?q?=C3=98yvind=20Kol=C3=A5s?= Date: Fri, 18 Aug 2017 23:31:22 +0200 Subject: [PATCH] make use of babl space for reference computations --- babl/babl-conversion.c | 19 +++++-- babl/babl-fish-reference.c | 41 ++++++++++---- babl/babl-fish.c | 47 ++++++++++++++-- babl/babl-format.c | 109 +++++++++++++++++++++++++++++++++---- babl/babl-format.h | 1 + babl/babl-internal.h | 4 ++ babl/babl-model.c | 62 +++++++++++++++++++-- babl/babl-model.h | 15 +++-- babl/babl.c | 1 + babl/base/model-gray.c | 27 +++++---- babl/base/model-rgb.c | 65 ++++++++++++---------- 11 files changed, 306 insertions(+), 85 deletions(-) diff --git a/babl/babl-conversion.c b/babl/babl-conversion.c index 766e6c4..9e45a5b 100644 --- a/babl/babl-conversion.c +++ b/babl/babl-conversion.c @@ -281,7 +281,7 @@ babl_conversion_new (const void *first_arg, babl = babl_db_exist (db, id, name); } - babl = _conversion_new (name, id, source, destination, linear, plane, planar, + babl = _conversion_new (name, id, source, destination, linear, plane, planar, user_data); /* Since there is not an already registered instance by the required @@ -300,8 +300,7 @@ babl_conversion_linear_process (BablConversion *conversion, void *destination, long n) { - return conversion->function.linear ((void*)conversion, - source, destination, n, conversion->data); + return conversion->function.linear ((void*)conversion, source, destination, n, conversion->data); } static long @@ -312,8 +311,7 @@ babl_conversion_plane_process (BablConversion *conversion, int dst_pitch, long n) { - return conversion->function.plane ((void*)conversion, - source, destination, + return conversion->function.plane ((void*)conversion, source, destination, src_pitch, dst_pitch, n, conversion->data); @@ -335,7 +333,6 @@ babl_conversion_planar_process (BablConversion *conversion, memcpy (src_data, source->data, sizeof (void *) * source->components); memcpy (dst_data, destination->data, sizeof (void *) * destination->components); - return conversion->function.planar ((void*)conversion, source->components, src_data, @@ -551,4 +548,14 @@ babl_conversion_error (BablConversion *conversion) return error; } +const Babl *babl_conversion_get_source_space (const Babl *conversion) +{ + return conversion->conversion.source->format.space; +} + +const Babl *babl_conversion_get_destination_space (const Babl *conversion) +{ + return conversion->conversion.destination->format.space; +} + BABL_CLASS_IMPLEMENT (conversion) diff --git a/babl/babl-fish-reference.c b/babl/babl-fish-reference.c index 00ff6be..8273da5 100644 --- a/babl/babl-fish-reference.c +++ b/babl/babl-fish-reference.c @@ -26,7 +26,8 @@ assert_conversion_find (const void *source, Babl *ret = babl_conversion_find (source, destination); if (!ret) - babl_fatal ("failed, aborting"); + babl_fatal ("failed finding conversion between %s and %s aborting", + babl_get_name (source), babl_get_name (destination)); return ret; } @@ -176,6 +177,7 @@ convert_to_double (BablFormat *source_fmt, src_img->pitch[0] = source_fmt->bytes_per_pixel; src_img->stride[0] = 0; + { /* i is source position */ for (i = 0; i < source_fmt->components; i++) { @@ -200,6 +202,7 @@ convert_to_double (BablFormat *source_fmt, src_img->data[0] += src_img->type[0]->bits / 8; } + } babl_free (src_img); babl_free (dst_img); } @@ -366,7 +369,6 @@ process_to_n_component (const Babl *babl, return 0; } - static int process_same_model (const Babl *babl, const char *source, @@ -433,17 +435,17 @@ babl_fish_reference_process (const Babl *babl, Babl *rgba_image; Babl *destination_image; - - if (BABL (babl->fish.source)->format.model == - BABL (babl->fish.destination)->format.model) + if ((BABL (babl->fish.source)->format.model == + BABL (babl->fish.destination)->format.model) && + (BABL (babl->fish.source)->format.space == + BABL (babl->fish.destination)->format.space) + ) return process_same_model (babl, source, destination, n); if (babl_format_is_format_n (BABL (babl->fish.destination))) { return process_to_n_component (babl, source, destination, n); } - - source_double_buf = babl_malloc (sizeof (double) * n * BABL (babl->fish.source)->format.model->components); @@ -454,7 +456,8 @@ babl_fish_reference_process (const Babl *babl, source_image = babl_image_from_linear ( source_double_buf, BABL (BABL ((babl->fish.source))->format.model)); rgba_image = babl_image_from_linear ( - rgba_double_buf, babl_model_from_id (BABL_RGBA)); + rgba_double_buf, babl_remodel_with_space (babl_model_from_id (BABL_RGBA), + BABL (BABL ((babl->fish.source))->format.space)) ); destination_image = babl_image_from_linear ( destination_double_buf, BABL (BABL ((babl->fish.destination))->format.model)); @@ -469,7 +472,8 @@ babl_fish_reference_process (const Babl *babl, Babl *conv = assert_conversion_find ( BABL (babl->fish.source)->format.model, - babl_model_from_id (BABL_RGBA) + babl_remodel_with_space (babl_model_from_id (BABL_RGBA), + BABL (BABL ((babl->fish.source))->format.space)) ); if (conv->class_type == BABL_CONVERSION_PLANAR) { @@ -488,10 +492,26 @@ babl_fish_reference_process (const Babl *babl, else babl_fatal ("oops"); } + if (((babl->fish.source)->format.space != + ((babl->fish.destination)->format.space))) + { + double matrix[9]; + int i; + double *rgba = rgba_double_buf; + babl_matrix_mul_matrix ( + (babl->fish.destination)->format.space->space.XYZtoRGB, + (babl->fish.source)->format.space->space.RGBtoXYZ, + matrix); + + for (i = 0; i < n; i++) + babl_matrix_mul_vector (matrix, &rgba[i * 4], &rgba[i * 4]); + } + { Babl *conv = assert_conversion_find ( - babl_model_from_id (BABL_RGBA), + babl_remodel_with_space (babl_model_from_id (BABL_RGBA), + BABL (BABL ((babl->fish.destination))->format.space)), BABL (babl->fish.destination)->format.model); if (conv->class_type == BABL_CONVERSION_PLANAR) { @@ -526,4 +546,3 @@ babl_fish_reference_process (const Babl *babl, babl_free (source_double_buf); return n; } - diff --git a/babl/babl-fish.c b/babl/babl-fish.c index 96c69c3..d8b7c7e 100644 --- a/babl/babl-fish.c +++ b/babl/babl-fish.c @@ -112,16 +112,55 @@ match_conversion (Babl *conversion, return 0; } + + Babl * babl_conversion_find (const void *source, const void *destination) { void *data = (void*)destination; - babl_list_each (BABL (source)->type.from_list, match_conversion, &data); - if (data == (void*)destination) /* didn't change */ - return NULL; - return data; + if (data != (void*)destination) /* didn't change */ + return data; + data = NULL; + + if (BABL (source)->class_type == BABL_MODEL) + { + const Babl *srgb_source = BABL (source)->model.data ? BABL (source)->model.data:source; + const Babl *srgb_destination = BABL (destination)->model.data ? BABL (destination)->model.data:destination; + Babl *reference = babl_conversion_find (srgb_source, srgb_destination); + BablConversion *ret; + + /* when conversions are sought between models, with non-sRGB chromaticities, + we create the needed conversions from existing ones on the fly, and + register them. The conversions registered by the models should pick up the + RGB chromaticities, and TRC to use from the space on the model instead of + hard-coding it. + */ + + switch (reference->instance.class_type) + { + case BABL_CONVERSION_LINEAR: + return _conversion_new ("", 0, source, destination, + reference->conversion.function.linear, + NULL, + NULL, + reference->conversion.data); + case BABL_CONVERSION_PLANE: + return _conversion_new ("", 0, source, destination, + NULL, + reference->conversion.function.plane, + NULL, + reference->conversion.data); + case BABL_CONVERSION_PLANAR: + return _conversion_new ("", 0, source, destination, + NULL, + NULL, + reference->conversion.function.planar, + reference->conversion.data); + } + } + return NULL; } int diff --git a/babl/babl-format.c b/babl/babl-format.c index 60a916e..a2c8e17 100644 --- a/babl/babl-format.c +++ b/babl/babl-format.c @@ -26,6 +26,7 @@ #include "babl-db.h" #include "babl-ref-pixels.h" + static int babl_format_destruct (void *babl) { BablFormat *format = babl; @@ -42,11 +43,12 @@ static int babl_format_destruct (void *babl) } static Babl * -format_new (const char *name, - int id, - int planar, - int components, - BablModel *model, +format_new (const char *name, + int id, + int planar, + int components, + BablModel *model, + const Babl *space, BablComponent **component, BablSampling **sampling, const BablType **type) @@ -83,6 +85,7 @@ format_new (const char *name, sizeof (BablType *) * (components) + sizeof (int) * (components) + sizeof (int) * (components)); + babl_set_destructor (babl, babl_format_destruct); babl->format.from_list = NULL; @@ -96,9 +99,13 @@ format_new (const char *name, strcpy (babl->instance.name, name); - babl->format.model = model; babl->format.components = components; + if (space == babl_space ("sRGB")) + babl->format.model = model; + else + babl->format.model = babl_remodel_with_space (model, space); + memcpy (babl->format.component, component, sizeof (BablComponent *) * components); memcpy (babl->format.type, type, sizeof (BablType *) * components); memcpy (babl->format.sampling, sampling, sizeof (BablSampling *) * components); @@ -118,9 +125,28 @@ format_new (const char *name, babl->format.format_n = 0; babl->format.palette = 0; + babl->format.space = (void*)space; + return babl; } +static Babl * +format_new_from_format_with_space (const Babl *format, const Babl *space) +{ + Babl *ret; + char new_name[256]; + sprintf (new_name, "%s-%s", babl_get_name ((void*)format), + babl_get_name ((void*)space)); + + ret = format_new (new_name, + 0, + format->format.planar, format->format.components, + (void*)babl_remodel_with_space (BABL(format->format.model), space), + space, + format->format.component, format->format.sampling, (void*)format->format.type); + return ret; +} + static char * create_name (const BablModel *model, @@ -190,7 +216,6 @@ create_name (const BablModel *model, return babl_strdup (buf); } - static char * ncomponents_create_name (const Babl *type, int components) @@ -244,6 +269,7 @@ babl_format_n (const Babl *btype, babl = format_new (name, id, planar, components, model, + babl_space("sRGB"), component, sampling, type); babl_format_set_is_format_n (babl); @@ -264,12 +290,12 @@ babl_format_is_format_n (const Babl *format) return 0; } - static int is_format_duplicate (Babl *babl, int planar, int components, BablModel *model, + const Babl *space, BablComponent **component, BablSampling **sampling, const BablType **type) @@ -278,7 +304,8 @@ is_format_duplicate (Babl *babl, if (babl->format.planar != planar || babl->format.components != components || - babl->format.model != model) + babl->format.model != model || + babl->format.space != (void*)space) return 0; for (i = 0; i < components; i++) @@ -301,6 +328,7 @@ babl_format_new (const void *first_arg, int planar = 0; int components = 0; BablModel *model = NULL; + const Babl * space = babl_space ("sRGB"); BablComponent *component [BABL_MAX_COMPONENTS]; BablSampling *sampling [BABL_MAX_COMPONENTS]; const BablType*type [BABL_MAX_COMPONENTS]; @@ -370,6 +398,10 @@ babl_format_new (const void *first_arg, current_sampling = (BablSampling *) arg; break; + case BABL_SPACE: + space = (Babl*) arg; + break; + case BABL_MODEL: if (model) { @@ -415,6 +447,15 @@ babl_format_new (const void *first_arg, if (!name) name = create_name (model, components, component, type); + if (space != babl_space ("sRGB")) + { + char *new_name = babl_malloc (strlen (name) + + strlen (babl_get_name ((Babl*)space)) + 1); + sprintf (new_name, "%s-%s", name, babl_get_name ((Babl*)space)); + babl_free (name); + name = new_name; + } + if (!model) { babl_log ("no model specified for format '%s'", name); @@ -438,7 +479,7 @@ babl_format_new (const void *first_arg, /* There is an instance already registered by the required id/name, * returning the preexistent one instead if it doesn't differ. */ - if (!is_format_duplicate (babl, planar, components, model, + if(0)if (!is_format_duplicate (babl, planar, components, model, space, component, sampling, type)) babl_fatal ("BablFormat '%s' already registered " "with different content!", name); @@ -447,9 +488,9 @@ babl_format_new (const void *first_arg, return babl; } - babl = format_new (name, + babl = format_new ((void*)name, id, - planar, components, model, + planar, components, model, space, component, sampling, type); babl_db_insert (db, babl); @@ -649,6 +690,50 @@ babl_format_get_model (const Babl *format) return NULL; } +const Babl * babl_format_get_space (const Babl *format) +{ + if (format->class_type == BABL_FORMAT) + { + return (Babl*)format->format.space; + } + return NULL; +} + BABL_CLASS_IMPLEMENT (format) +const Babl * +babl_format_with_space (const char *name, const Babl *space) +{ + const Babl *ret = NULL; + + if (!space) space = babl_space ("sRGB"); + if (space->class_type == BABL_FORMAT) + { + space = space->format.space; + } + else if (space->class_type == BABL_MODEL) + { + space = space->model.space; + } + else if (space->class_type != BABL_SPACE) + { + return NULL; + } + if (space == babl_space("sRGB")) + return babl_format (name); + + { + char *new_name = babl_malloc (strlen (name) + + strlen (babl_get_name ((Babl*)space)) + 1); + sprintf (new_name, "%s-%s", name, babl_get_name ((Babl*)space)); + + ret = babl_db_exist_by_name (db, new_name); + if (ret) + return ret; + + ret = format_new_from_format_with_space (babl_format (name), space); + } + return ret; +} + diff --git a/babl/babl-format.h b/babl/babl-format.h index bc78f42..333b5ba 100644 --- a/babl/babl-format.h +++ b/babl/babl-format.h @@ -29,6 +29,7 @@ typedef struct BablComponent **component; BablType **type; void *model_data; + const Babl *space; void *image_template; /* image template for use with linear (non-planer) images */ diff --git a/babl/babl-internal.h b/babl/babl-internal.h index c193998..6ed9195 100644 --- a/babl/babl-internal.h +++ b/babl/babl-internal.h @@ -319,6 +319,10 @@ static inline double babl_parse_double (const char *str) return result; } +const Babl * +babl_remodel_with_space (const Babl *model, const Babl *space); +const Babl * +babl_model_with_space (const char *name, const Babl *space); Babl * _conversion_new (const char *name, int id, diff --git a/babl/babl-model.c b/babl/babl-model.c index 02f3c0b..2cec2c3 100644 --- a/babl/babl-model.c +++ b/babl/babl-model.c @@ -33,7 +33,7 @@ babl_model_destroy (void *data) Babl *babl = data; if (babl->model.from_list) babl_free (babl->model.from_list); - return 0; + return 0; } static char * @@ -53,6 +53,7 @@ babl_model_create_name (int components, static Babl * model_new (const char *name, + const Babl *space, int id, int components, BablComponent **component) @@ -69,6 +70,7 @@ model_new (const char *name, babl->class_type = BABL_MODEL; babl->instance.id = id; babl->model.components = components; + babl->model.space = space; strcpy (babl->instance.name, name); memcpy (babl->model.component, component, sizeof (BablComponent *) * components); @@ -77,10 +79,13 @@ model_new (const char *name, } static int -is_model_duplicate (Babl *babl, int components, BablComponent **component) +is_model_duplicate (Babl *babl, const Babl *space, int components, BablComponent **component) { int i; + if (babl->model.space != space) + return 0; + if (babl->model.components != components) return 0; @@ -105,6 +110,7 @@ babl_model_new (void *first_argument, const char *arg = first_argument; const char *assigned_name = NULL; char *name = NULL; + const Babl *space = babl_space ("sRGB"); BablComponent *component [BABL_MAX_COMPONENTS]; va_start (varg, first_argument); @@ -143,6 +149,10 @@ babl_model_new (void *first_argument, babl_log ("submodels not handled yet"); break; + case BABL_SPACE: + space = bablc; + break; + case BABL_TYPE: case BABL_TYPE_INTEGER: case BABL_TYPE_FLOAT: @@ -172,7 +182,7 @@ babl_model_new (void *first_argument, else { babl_fatal ("unhandled argument '%s' for babl_model '%s'", - arg, assigned_name ? assigned_name : "(unnamed)"); + arg, assigned_name ? assigned_name : "(unnamed)"); } arg = va_arg (varg, char *); @@ -199,13 +209,13 @@ babl_model_new (void *first_argument, if (! babl) { - babl = model_new (name, id, components, component); + babl = model_new (name, space, id, components, component); babl_db_insert (db, babl); construct_double_format (babl); } else { - if (!is_model_duplicate (babl, components, component)) + if (!is_model_duplicate (babl, space, components, component)) babl_fatal ("BablModel '%s' already registered " "with different components!", name); } @@ -350,3 +360,45 @@ babl_model_is_symmetric (const Babl *cbabl) } BABL_CLASS_IMPLEMENT (model) + +/* XXX: probably better to do like with babl_format, add a -suffix and + * insert in normal database than to have this static cache list + */ +static const Babl *babl_remodels[512]={NULL,}; +int babl_n_remodels = 0; + +const Babl * +babl_remodel_with_space (const Babl *model, const Babl *space) +{ + Babl *ret; + int i; + + if (model->model.space == space) + return (void*)model; + + /* get back to the sRGB model if we are in a COW clone of it */ + if (model->model.data) + model = (void*)model->model.data; + + for (i = 0; i < babl_n_remodels; i++) + { + if (babl_remodels[i]->model.data == model && + babl_remodels[i]->model.space == space) + return babl_remodels[i]; + } + + ret = babl_calloc (sizeof (BablModel), 1); + memcpy (ret, model, sizeof (BablModel)); + ret->model.space = space; + ret->model.data = (void*)model; /* use the data as a backpointer to original model */ + return babl_remodels[babl_n_remodels++] = ret; + return (Babl*)ret; +} + +const Babl * +babl_model_with_space (const char *name, const Babl *space) +{ + return babl_remodel_with_space (babl_model (name), space); +} + + diff --git a/babl/babl-model.h b/babl/babl-model.h index 4561fdb..2395005 100644 --- a/babl/babl-model.h +++ b/babl/babl-model.h @@ -23,13 +23,16 @@ BABL_CLASS_DECLARE (model); typedef struct { - BablInstance instance; + BablInstance instance; BablList *from_list; - int components; - BablComponent **component; - BablType **type; /*< must be doubles, - used here for convenience in code */ - void *data; /* used for palette */ + int components; + BablComponent **component; + BablType **type; /*< must be doubles, + used here for convenience in code */ + void *data; /* used for palette - and maybe back pointer + to actual model? + */ + const Babl *space; } BablModel; #endif diff --git a/babl/babl.c b/babl/babl.c index 9924fa7..7d5bf09 100644 --- a/babl/babl.c +++ b/babl/babl.c @@ -135,6 +135,7 @@ babl_init (void) char * dir_list; babl_internal_init (); + babl_space_class_init (); babl_sampling_class_init (); babl_type_db (); babl_component_db (); diff --git a/babl/base/model-gray.c b/babl/base/model-gray.c index d2e7d68..ef10ce7 100644 --- a/babl/base/model-gray.c +++ b/babl/base/model-gray.c @@ -22,7 +22,6 @@ #include "babl-classes.h" #include "babl.h" #include "babl-ids.h" -#include "util.h" #include "rgb-constants.h" #include "math.h" #include "babl-base.h" @@ -165,7 +164,6 @@ rgba_to_gray (Babl *conversion, return n; } - static long rgb_to_gray_2_2 (Babl *conversion, int src_bands, @@ -176,6 +174,7 @@ rgb_to_gray_2_2 (Babl *conversion, int *dst_pitch, long n) { + const Babl *space = babl_conversion_get_destination_space (conversion); BABL_PLANAR_SANITY while (n--) { @@ -190,10 +189,10 @@ rgb_to_gray_2_2 (Babl *conversion, else alpha = 1.0; - luminance = red * RGB_LUMINANCE_RED + + luminance = red * RGB_LUMINANCE_RED + // XXX: should be taken from BablSpace green * RGB_LUMINANCE_GREEN + - blue * RGB_LUMINANCE_BLUE; - *(double *) dst[0] = linear_to_gamma_2_2 (luminance); + blue * RGB_LUMINANCE_BLUE; + *(double *) dst[0] = babl_space_from_linear (space, luminance); if (dst_bands == 2) *(double *) dst[1] = alpha; @@ -205,7 +204,7 @@ rgb_to_gray_2_2 (Babl *conversion, static long -gray_2_2_to_rgb (Babl *conversion, +gray_2_2_to_rgb (Babl *conversion, int src_bands, char **src, int *src_pitch, @@ -214,6 +213,7 @@ gray_2_2_to_rgb (Babl *conversion, int *dst_pitch, long n) { + const Babl *space = babl_conversion_get_source_space (conversion); BABL_PLANAR_SANITY while (n--) { @@ -221,7 +221,7 @@ gray_2_2_to_rgb (Babl *conversion, double red, green, blue; double alpha; - luminance = gamma_2_2_to_linear (*(double *) src[0]); + luminance = babl_space_to_linear (space, *(double *) src[0]); red = luminance; green = luminance; blue = luminance; @@ -302,7 +302,7 @@ gray_to_rgba (Babl *conversion, } static long -gray_alpha_premultiplied_to_rgba (Babl *conversion, +gray_alpha_premultiplied_to_rgba (Babl *conversion, int src_bands, char **src, int *src_pitch, @@ -340,7 +340,7 @@ gray_alpha_premultiplied_to_rgba (Babl *conversion, static long -rgba_to_gray_alpha_premultiplied (Babl *conversion, +rgba_to_gray_alpha_premultiplied (Babl *conversion, int src_bands, char **src, int *src_pitch, @@ -445,6 +445,8 @@ rgba2gray_gamma_2_2_premultiplied (Babl *conversion, char *dst, long n) { + const Babl *space = babl_conversion_get_destination_space (conversion); + while (n--) { double red = ((double *) src)[0]; @@ -458,7 +460,7 @@ rgba2gray_gamma_2_2_premultiplied (Babl *conversion, luminance = red * RGB_LUMINANCE_RED + green * RGB_LUMINANCE_GREEN + blue * RGB_LUMINANCE_BLUE; - luma = linear_to_gamma_2_2 (luminance); + luma = babl_space_from_linear (space, luminance); ((double *) dst)[0] = luma * alpha; ((double *) dst)[1] = alpha; @@ -469,12 +471,15 @@ rgba2gray_gamma_2_2_premultiplied (Babl *conversion, return n; } + static long gray_gamma_2_2_premultiplied2rgba (Babl *conversion, char *src, char *dst, long n) { + const Babl *space = babl_conversion_get_destination_space (conversion); + while (n--) { double luma = ((double *) src)[0]; @@ -482,7 +487,7 @@ gray_gamma_2_2_premultiplied2rgba (Babl *conversion, double luminance; luma = luma / alpha; - luminance = gamma_2_2_to_linear (luma); + luminance = babl_space_to_linear (space, luma); ((double *) dst)[0] = luminance; ((double *) dst)[1] = luminance; diff --git a/babl/base/model-rgb.c b/babl/base/model-rgb.c index 69c3b53..b181888 100644 --- a/babl/base/model-rgb.c +++ b/babl/base/model-rgb.c @@ -23,7 +23,6 @@ #include "babl.h" #include "babl-classes.h" #include "babl-ids.h" -#include "util.h" #include "babl-base.h" static void models (void); @@ -151,7 +150,7 @@ models (void) } static long -copy_strip_1 (BablConversion *conversion, +copy_strip_1 (Babl *conversion, int src_bands, char **src, int *src_pitch, @@ -183,7 +182,7 @@ copy_strip_1 (BablConversion *conversion, } static long -g3_gamma_2_2 (BablConversion *conversion, +g3_gamma_2_2 (Babl *conversion, int src_bands, char **src, int *src_pitch, @@ -192,6 +191,8 @@ g3_gamma_2_2 (BablConversion *conversion, int *dst_pitch, long samples) { + const Babl *space = babl_conversion_get_destination_space (conversion); + long n = samples; BABL_PLANAR_SANITY @@ -199,7 +200,7 @@ g3_gamma_2_2 (BablConversion *conversion, { int band; for (band = 0; band < 3; band++) - *(double *) dst[band] = linear_to_gamma_2_2 (*(double *) src[band]); + *(double *) dst[band] = babl_space_from_linear (space, (*(double *) src[band])); for (; band < dst_bands; band++) *(double *) dst[band] = *(double *) src[band]; @@ -210,7 +211,7 @@ g3_gamma_2_2 (BablConversion *conversion, static long -g3_inv_gamma_2_2 (BablConversion *conversion, +g3_inv_gamma_2_2 (Babl *conversion, int src_bands, char **src, int *src_pitch, @@ -219,6 +220,7 @@ g3_inv_gamma_2_2 (BablConversion *conversion, int *dst_pitch, long samples) { + const Babl *space = babl_conversion_get_source_space (conversion); long n = samples; BABL_PLANAR_SANITY @@ -227,7 +229,7 @@ g3_inv_gamma_2_2 (BablConversion *conversion, int band; for (band = 0; band < 3; band++) { - *(double *) dst[band] = gamma_2_2_to_linear (*(double *) src[band]); + *(double *) dst[band] = babl_space_to_linear (space, (*(double *) src[band])); } for (; band < dst_bands; band++) { @@ -242,7 +244,7 @@ g3_inv_gamma_2_2 (BablConversion *conversion, } static long -non_premultiplied_to_premultiplied (BablConversion *conversion, +non_premultiplied_to_premultiplied (Babl *conversion, int src_bands, char **src, int *src_pitch, @@ -272,7 +274,7 @@ non_premultiplied_to_premultiplied (BablConversion *conversion, } static long -premultiplied_to_non_premultiplied (BablConversion *conversion, +premultiplied_to_non_premultiplied (Babl *conversion, int src_bands, char **src, int *src_pitch, @@ -311,19 +313,20 @@ premultiplied_to_non_premultiplied (BablConversion *conversion, static long -rgba2rgba_gamma_2_2_premultiplied (BablConversion *conversion, +rgba2rgba_gamma_2_2_premultiplied (Babl *conversion, char *src, char *dst, long samples) { + const Babl *space = babl_conversion_get_destination_space (conversion); long n = samples; while (n--) { double alpha = ((double *) src)[3]; - ((double *) dst)[0] = linear_to_gamma_2_2 (((double *) src)[0]) * alpha; - ((double *) dst)[1] = linear_to_gamma_2_2 (((double *) src)[1]) * alpha; - ((double *) dst)[2] = linear_to_gamma_2_2 (((double *) src)[2]) * alpha; + ((double *) dst)[0] = babl_space_from_linear (space, ((double *) src)[0]) * alpha; + ((double *) dst)[1] = babl_space_from_linear (space, ((double *) src)[1]) * alpha; + ((double *) dst)[2] = babl_space_from_linear (space, ((double *) src)[2]) * alpha; ((double *) dst)[3] = alpha; src += 4 * sizeof (double); dst += 4 * sizeof (double); @@ -333,11 +336,12 @@ rgba2rgba_gamma_2_2_premultiplied (BablConversion *conversion, static long -rgba_gamma_2_2_premultiplied2rgba (BablConversion *conversion, +rgba_gamma_2_2_premultiplied2rgba (Babl *conversion, char *src, char *dst, long samples) { + const Babl *space = babl_conversion_get_source_space (conversion); long n = samples; while (n--) @@ -345,9 +349,9 @@ rgba_gamma_2_2_premultiplied2rgba (BablConversion *conversion, double alpha = ((double *) src)[3]; if (alpha > BABL_ALPHA_THRESHOLD) { - ((double *) dst)[0] = gamma_2_2_to_linear (((double *) src)[0] / alpha); - ((double *) dst)[1] = gamma_2_2_to_linear (((double *) src)[1] / alpha); - ((double *) dst)[2] = gamma_2_2_to_linear (((double *) src)[2] / alpha); + ((double *) dst)[0] = babl_space_to_linear (space, ((double *) src)[0] / alpha); + ((double *) dst)[1] = babl_space_to_linear (space, ((double *) src)[1] / alpha); + ((double *) dst)[2] = babl_space_to_linear (space, ((double *) src)[2] / alpha); } else { @@ -365,19 +369,20 @@ rgba_gamma_2_2_premultiplied2rgba (BablConversion *conversion, static long -rgba2rgba_gamma_2_2 (BablConversion *conversion, - char *src, - char *dst, - long samples) +rgba2rgba_gamma_2_2 (Babl *conversion, + char *src, + char *dst, + long samples) { + const Babl *space = babl_conversion_get_destination_space (conversion); long n = samples; while (n--) { double alpha = ((double *) src)[3]; - ((double *) dst)[0] = linear_to_gamma_2_2 (((double *) src)[0]); - ((double *) dst)[1] = linear_to_gamma_2_2 (((double *) src)[1]); - ((double *) dst)[2] = linear_to_gamma_2_2 (((double *) src)[2]); + ((double *) dst)[0] = babl_space_from_linear (space, ((double *) src)[0]); + ((double *) dst)[1] = babl_space_from_linear (space, ((double *) src)[1]); + ((double *) dst)[2] = babl_space_from_linear (space, ((double *) src)[2]); ((double *) dst)[3] = alpha; src += 4 * sizeof (double); dst += 4 * sizeof (double); @@ -387,19 +392,20 @@ rgba2rgba_gamma_2_2 (BablConversion *conversion, static long -rgba_gamma_2_22rgba (BablConversion *conversion, +rgba_gamma_2_22rgba (Babl *conversion, char *src, char *dst, long samples) { + const Babl *space = babl_conversion_get_source_space (conversion); long n = samples; while (n--) { double alpha = ((double *) src)[3]; - ((double *) dst)[0] = gamma_2_2_to_linear (((double *) src)[0]); - ((double *) dst)[1] = gamma_2_2_to_linear (((double *) src)[1]); - ((double *) dst)[2] = gamma_2_2_to_linear (((double *) src)[2]); + ((double *) dst)[0] = babl_space_to_linear (space, ((double *) src)[0]); + ((double *) dst)[1] = babl_space_to_linear (space, ((double *) src)[1]); + ((double *) dst)[2] = babl_space_to_linear (space, ((double *) src)[2]); ((double *) dst)[3] = alpha; src += 4 * sizeof (double); @@ -487,7 +493,6 @@ static void formats (void) { babl_format_new ( - /*"name", "srgb",*/ "id", BABL_SRGB, babl_model_from_id (BABL_RGB_GAMMA_2_2), babl_type_from_id (BABL_U8), @@ -508,8 +513,8 @@ formats (void) babl_format_new ( "id", BABL_RGBA_FLOAT, - babl_model_from_id (BABL_RGBA), - babl_type_from_id (BABL_FLOAT), + babl_model_from_id (BABL_RGBA), + babl_type_from_id (BABL_FLOAT), babl_component_from_id (BABL_RED), babl_component_from_id (BABL_GREEN), babl_component_from_id (BABL_BLUE), -- 2.30.2